home *** CD-ROM | disk | FTP | other *** search
/ Aminet 39 / Aminet 39 (2000)(Schatztruhe)[!][Oct 2000].iso / Aminet / dev / c / AsyncIOPPCdev.lha / AsyncIOPPCdev / PPCInclude / powerup / ppcpragmas / asyncio_pragmas.h
Encoding:
C/C++ Source or Header  |  2000-02-03  |  9.5 KB  |  332 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_ASYNCIO_H
  4. #define _PPCPRAGMA_ASYNCIO_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE_ASYNCIO_H
  7. #include <powerup/ppcinline/asyncio.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef ASYNCIO_BASE_NAME
  24. #define ASYNCIO_BASE_NAME AsyncIOBase
  25. #endif /* !ASYNCIO_BASE_NAME */
  26.  
  27. #ifdef ASIO_NOEXTERNALS
  28. #define    OpenAsync(fileName, mode, bufferSize, SysBase, DOSBase)    _OpenAsync(ASYNCIO_BASE_NAME, fileName, mode, bufferSize, SysBase, DOSBase)
  29.  
  30. static __inline AsyncFile *
  31. _OpenAsync(void *AsyncIOBase, const STRPTR fileName, OpenModes mode, LONG bufferSize, struct ExecBase *SysBase, struct DosLibrary *DOSBase)
  32. {
  33. struct Caos    MyCaos;
  34.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  35. //    MyCaos.M68kStart    =    NULL;
  36. //    MyCaos.M68kSize        =    0;
  37.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  38. //    MyCaos.PPCStart        =    NULL;
  39. //    MyCaos.PPCSize        =    0;
  40.     MyCaos.a0        =(ULONG) fileName;
  41.     MyCaos.d0        =(ULONG) mode;
  42.     MyCaos.d1        =(ULONG) bufferSize;
  43.     MyCaos.a1        =(ULONG) SysBase;
  44.     MyCaos.a2        =(ULONG) DOSBase;
  45.     MyCaos.caos_Un.Offset    =    (-30);
  46.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  47.     return((AsyncFile *)PPCCallOS(&MyCaos));
  48. }
  49.  
  50. #define    OpenAsyncFromFH(handle, mode, bufferSize, SysBase, DOSBase)    _OpenAsyncFromFH(ASYNCIO_BASE_NAME, handle, mode, bufferSize, SysBase, DOSBase)
  51.  
  52. static __inline AsyncFile *
  53. _OpenAsyncFromFH(void *AsyncIOBase, BPTR handle, OpenModes mode, LONG bufferSize, struct ExecBase *SysBase, struct DosLibrary *DOSBase)
  54. {
  55. struct Caos    MyCaos;
  56.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  57. //    MyCaos.M68kStart    =    NULL;
  58. //    MyCaos.M68kSize        =    0;
  59.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  60. //    MyCaos.PPCStart        =    NULL;
  61. //    MyCaos.PPCSize        =    0;
  62.     MyCaos.a0        =(ULONG) handle;
  63.     MyCaos.d0        =(ULONG) mode;
  64.     MyCaos.d1        =(ULONG) bufferSize;
  65.     MyCaos.a1        =(ULONG) SysBase;
  66.     MyCaos.a2        =(ULONG) DOSBase;
  67.     MyCaos.caos_Un.Offset    =    (-36);
  68.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  69.     return((AsyncFile *)PPCCallOS(&MyCaos));
  70. }
  71.  
  72. #else
  73.  
  74. #define    OpenAsync(fileName, mode, bufferSize)    _OpenAsync(ASYNCIO_BASE_NAME, fileName, mode, bufferSize)
  75.  
  76. static __inline AsyncFile *
  77. _OpenAsync(void *AsyncIOBase, const STRPTR fileName, OpenModes mode, LONG bufferSize)
  78. {
  79. struct Caos    MyCaos;
  80.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  81. //    MyCaos.M68kStart    =    NULL;
  82. //    MyCaos.M68kSize        =    0;
  83.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  84. //    MyCaos.PPCStart        =    NULL;
  85. //    MyCaos.PPCSize        =    0;
  86.     MyCaos.a0        =(ULONG) fileName;
  87.     MyCaos.d0        =(ULONG) mode;
  88.     MyCaos.d1        =(ULONG) bufferSize;
  89.     MyCaos.caos_Un.Offset    =    (-30);
  90.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  91.     return((AsyncFile *)PPCCallOS(&MyCaos));
  92. }
  93.  
  94. #define    OpenAsyncFromFH(handle, mode, bufferSize)    _OpenAsyncFromFH(ASYNCIO_BASE_NAME, handle, mode, bufferSize)
  95.  
  96. static __inline AsyncFile *
  97. _OpenAsyncFromFH(void *AsyncIOBase, BPTR handle, OpenModes mode, LONG bufferSize)
  98. {
  99. struct Caos    MyCaos;
  100.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  101. //    MyCaos.M68kStart    =    NULL;
  102. //    MyCaos.M68kSize        =    0;
  103.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  104. //    MyCaos.PPCStart        =    NULL;
  105. //    MyCaos.PPCSize        =    0;
  106.     MyCaos.a0        =(ULONG) handle;
  107.     MyCaos.d0        =(ULONG) mode;
  108.     MyCaos.d1        =(ULONG) bufferSize;
  109.     MyCaos.caos_Un.Offset    =    (-36);
  110.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  111.     return((AsyncFile *)PPCCallOS(&MyCaos));
  112. }
  113. #endif /* ASIO_NOEXTERNALS */
  114.  
  115. #define    CloseAsync(file)    _CloseAsync(ASYNCIO_BASE_NAME, file)
  116.  
  117. static __inline LONG
  118. _CloseAsync(void *AsyncIOBase, AsyncFile *file)
  119. {
  120. struct Caos    MyCaos;
  121.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  122. //    MyCaos.M68kStart    =    NULL;
  123. //    MyCaos.M68kSize        =    0;
  124.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  125. //    MyCaos.PPCStart        =    NULL;
  126. //    MyCaos.PPCSize        =    0;
  127.     MyCaos.a0        =(ULONG) file;
  128.     MyCaos.caos_Un.Offset    =    (-42);
  129.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  130.     return((LONG)PPCCallOS(&MyCaos));
  131. }
  132.  
  133. #define    PeekAsync(file, buffer, numBytes)    _PeekAsync(ASYNCIO_BASE_NAME, file, buffer, numBytes)
  134.  
  135. static __inline LONG
  136. _PeekAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG numBytes)
  137. {
  138. struct Caos    MyCaos;
  139.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  140. //    MyCaos.M68kStart    =    NULL;
  141. //    MyCaos.M68kSize        =    0;
  142.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  143. //    MyCaos.PPCStart        =    NULL;
  144. //    MyCaos.PPCSize        =    0;
  145.     MyCaos.a0        =(ULONG) file;
  146.     MyCaos.a1        =(ULONG) buffer;
  147.     MyCaos.d0        =(ULONG) numBytes;
  148.     MyCaos.caos_Un.Offset    =    (-102);
  149.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  150.     return((LONG)PPCCallOS(&MyCaos));
  151. }
  152.  
  153. #define    ReadAsync(file, buffer, numBytes)    _ReadAsync(ASYNCIO_BASE_NAME, file, buffer, numBytes)
  154.  
  155. static __inline LONG
  156. _ReadAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG numBytes)
  157. {
  158. struct Caos    MyCaos;
  159.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  160. //    MyCaos.M68kStart    =    NULL;
  161. //    MyCaos.M68kSize        =    0;
  162.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  163. //    MyCaos.PPCStart        =    NULL;
  164. //    MyCaos.PPCSize        =    0;
  165.     MyCaos.a0        =(ULONG) file;
  166.     MyCaos.a1        =(ULONG) buffer;
  167.     MyCaos.d0        =(ULONG) numBytes;
  168.     MyCaos.caos_Un.Offset    =    (-54);
  169.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  170.     return((LONG)PPCCallOS(&MyCaos));
  171. }
  172.  
  173. #define    ReadCharAsync(file)    _ReadCharAsync(ASYNCIO_BASE_NAME, file)
  174.  
  175. static __inline LONG
  176. _ReadCharAsync(void *AsyncIOBase, AsyncFile *file)
  177. {
  178. struct Caos    MyCaos;
  179.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  180. //    MyCaos.M68kStart    =    NULL;
  181. //    MyCaos.M68kSize        =    0;
  182.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  183. //    MyCaos.PPCStart        =    NULL;
  184. //    MyCaos.PPCSize        =    0;
  185.     MyCaos.a0        =(ULONG) file;
  186.     MyCaos.caos_Un.Offset    =    (-66);
  187.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  188.     return((LONG)PPCCallOS(&MyCaos));
  189. }
  190.  
  191. #define    ReadLineAsync(file, buffer, size)    _ReadLineAsync(ASYNCIO_BASE_NAME, file, buffer, size)
  192.  
  193. static __inline LONG
  194. _ReadLineAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG size)
  195. {
  196. struct Caos    MyCaos;
  197.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  198. //    MyCaos.M68kStart    =    NULL;
  199. //    MyCaos.M68kSize        =    0;
  200.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  201. //    MyCaos.PPCStart        =    NULL;
  202. //    MyCaos.PPCSize        =    0;
  203.     MyCaos.a0        =(ULONG) file;
  204.     MyCaos.a1        =(ULONG) buffer;
  205.     MyCaos.d0        =(ULONG) size;
  206.     MyCaos.caos_Un.Offset    =    (-78);
  207.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  208.     return((LONG)PPCCallOS(&MyCaos));
  209. }
  210.  
  211. #define    FGetsAsync(file, buffer, size)    _FGetsAsync(ASYNCIO_BASE_NAME, file, buffer, size)
  212.  
  213. static __inline APTR
  214. _FGetsAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG size)
  215. {
  216. struct Caos    MyCaos;
  217.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  218. //    MyCaos.M68kStart    =    NULL;
  219. //    MyCaos.M68kSize        =    0;
  220.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  221. //    MyCaos.PPCStart        =    NULL;
  222. //    MyCaos.PPCSize        =    0;
  223.     MyCaos.a0        =(ULONG) file;
  224.     MyCaos.a1        =(ULONG) buffer;
  225.     MyCaos.d0        =(ULONG) size;
  226.     MyCaos.caos_Un.Offset    =    (-90);
  227.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  228.     return((APTR)PPCCallOS(&MyCaos));
  229. }
  230.  
  231. #define    FGetsLenAsync(file, buffer, size, length)    _FGetsLenAsync(ASYNCIO_BASE_NAME, file, buffer, size, length)
  232.  
  233. static __inline APTR
  234. _FGetsLenAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG size, LONG *length)
  235. {
  236. struct Caos    MyCaos;
  237.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  238. //    MyCaos.M68kStart    =    NULL;
  239. //    MyCaos.M68kSize        =    0;
  240.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  241. //    MyCaos.PPCStart        =    NULL;
  242. //    MyCaos.PPCSize        =    0;
  243.     MyCaos.a0        =(ULONG) file;
  244.     MyCaos.a1        =(ULONG) buffer;
  245.     MyCaos.d0        =(ULONG) size;
  246.     MyCaos.a2        =(ULONG) length;
  247.     MyCaos.caos_Un.Offset    =    (-96);
  248.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  249.     return((APTR)PPCCallOS(&MyCaos));
  250. }
  251.  
  252. #define    WriteAsync(file, buffer, numBytes)    _WriteAsync(ASYNCIO_BASE_NAME, file, buffer, numBytes)
  253.  
  254. static __inline LONG
  255. _WriteAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG numBytes)
  256. {
  257. struct Caos    MyCaos;
  258.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  259. //    MyCaos.M68kStart    =    NULL;
  260. //    MyCaos.M68kSize        =    0;
  261.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  262. //    MyCaos.PPCStart        =    NULL;
  263. //    MyCaos.PPCSize        =    0;
  264.     MyCaos.a0        =(ULONG) file;
  265.     MyCaos.a1        =(ULONG) buffer;
  266.     MyCaos.d0        =(ULONG) numBytes;
  267.     MyCaos.caos_Un.Offset    =    (-60);
  268.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  269.     return((LONG)PPCCallOS(&MyCaos));
  270. }
  271.  
  272. #define    WriteCharAsync(file, ch)    _WriteCharAsync(ASYNCIO_BASE_NAME, file, ch)
  273.  
  274. static __inline LONG
  275. _WriteCharAsync(void *AsyncIOBase, AsyncFile *file, UBYTE ch)
  276. {
  277. struct Caos    MyCaos;
  278.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  279. //    MyCaos.M68kStart    =    NULL;
  280. //    MyCaos.M68kSize        =    0;
  281.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  282. //    MyCaos.PPCStart        =    NULL;
  283. //    MyCaos.PPCSize        =    0;
  284.     MyCaos.a0        =(ULONG) file;
  285.     MyCaos.d0        =(ULONG) ch;
  286.     MyCaos.caos_Un.Offset    =    (-72);
  287.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  288.     return((LONG)PPCCallOS(&MyCaos));
  289. }
  290.  
  291. #define    WriteLineAsync(file, line)    _WriteLineAsync(ASYNCIO_BASE_NAME, file, line)
  292.  
  293. static __inline LONG
  294. _WriteLineAsync(void *AsyncIOBase, AsyncFile *file, STRPTR line)
  295. {
  296. struct Caos    MyCaos;
  297.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  298. //    MyCaos.M68kStart    =    NULL;
  299. //    MyCaos.M68kSize        =    0;
  300.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  301. //    MyCaos.PPCStart        =    NULL;
  302. //    MyCaos.PPCSize        =    0;
  303.     MyCaos.a0        =(ULONG) file;
  304.     MyCaos.a1        =(ULONG) line;
  305.     MyCaos.caos_Un.Offset    =    (-84);
  306.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  307.     return((LONG)PPCCallOS(&MyCaos));
  308. }
  309.  
  310. #define    SeekAsync(file, position, mode)    _SeekAsync(ASYNCIO_BASE_NAME, file, position, mode)
  311.  
  312. static __inline LONG
  313. _SeekAsync(void *AsyncIOBase, AsyncFile *file, LONG position, SeekModes mode)
  314. {
  315. struct Caos    MyCaos;
  316.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  317. //    MyCaos.M68kStart    =    NULL;
  318. //    MyCaos.M68kSize        =    0;
  319.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  320. //    MyCaos.PPCStart        =    NULL;
  321. //    MyCaos.PPCSize        =    0;
  322.     MyCaos.a0        =(ULONG) file;
  323.     MyCaos.d0        =(ULONG) position;
  324.     MyCaos.d1        =(ULONG) mode;
  325.     MyCaos.caos_Un.Offset    =    (-48);
  326.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  327.     return((LONG)PPCCallOS(&MyCaos));
  328. }
  329.  
  330. #endif /* SASC Pragmas */
  331. #endif /* !_PPCPRAGMA_ASYNCIO_H */
  332.